home *** CD-ROM | disk | FTP | other *** search
/ CU Amiga Super CD-ROM 15 / CU Amiga Magazine's Super CD-ROM 15 (1997)(EMAP Images)(GB)[!][issue 1997-10].iso / CUCD / Graphics / Ghostscript / source / gschar.c < prev    next >
Encoding:
C/C++ Source or Header  |  1997-05-30  |  42.4 KB  |  1,396 lines
  1. /* Copyright (C) 1989, 1995, 1996, 1997 Aladdin Enterprises.  All rights reserved.
  2.   
  3.   This file is part of Aladdin Ghostscript.
  4.   
  5.   Aladdin Ghostscript is distributed with NO WARRANTY OF ANY KIND.  No author
  6.   or distributor accepts any responsibility for the consequences of using it,
  7.   or for whether it serves any particular purpose or works at all, unless he
  8.   or she says so in writing.  Refer to the Aladdin Ghostscript Free Public
  9.   License (the "License") for full details.
  10.   
  11.   Every copy of Aladdin Ghostscript must include a copy of the License,
  12.   normally in a plain ASCII text file named PUBLIC.  The License grants you
  13.   the right to copy, modify and redistribute Aladdin Ghostscript, but only
  14.   under certain conditions described in the License.  Among other things, the
  15.   License requires that the copyright notice and this notice be preserved on
  16.   all copies.
  17. */
  18.  
  19. /* gschar.c */
  20. /* Character writing operators for Ghostscript library */
  21. #include "gx.h"
  22. #include "memory_.h"
  23. #include "string_.h"
  24. #include "gserrors.h"
  25. #include "gsstruct.h"
  26. #include "gxfixed.h"            /* ditto */
  27. #include "gxarith.h"
  28. #include "gxmatrix.h"
  29. #include "gzstate.h"
  30. #include "gxcoord.h"
  31. #include "gxdevice.h"
  32. #include "gxdevmem.h"
  33. #include "gxchar.h"
  34. #include "gxfont.h"
  35. #include "gxfont0.h"
  36. #include "gxfcache.h"
  37. #include "gspath.h"
  38. #include "gzpath.h"
  39.  
  40. /* Define whether or not to cache characters rotated by angles other than */
  41. /* multiples of 90 degrees. */
  42. #define CACHE_ROTATED_CHARS 1
  43.  
  44. /* Define whether or not to oversample characters at small sizes. */
  45. #define OVERSAMPLE 1
  46.  
  47. /* Define the maximum size of a full temporary bitmap when rasterizing, */
  48. /* in bits (not bytes). */
  49. #define MAX_TEMP_BITMAP_BITS 80000
  50.  
  51. /* Structure descriptors */
  52. private_st_gs_show_enum();
  53. #define eptr ((gs_show_enum *)vptr)
  54. private ENUM_PTRS_BEGIN(show_enum_enum_ptrs) {
  55.     if ( index > eptr->fstack.depth + 6 )
  56.       return 0;
  57.     ENUM_RETURN(eptr->fstack.items[index - 6].font);
  58.     }
  59.     ENUM_PTR(0, gs_show_enum, pgs);
  60.     ENUM_CONST_STRING_PTR(1, gs_show_enum, str);
  61.     ENUM_PTR(2, gs_show_enum, show_gstate);
  62.     ENUM_PTR(3, gs_show_enum, dev_cache);
  63.     ENUM_PTR(4, gs_show_enum, dev_cache2);
  64.     ENUM_PTR(5, gs_show_enum, dev_null);
  65. ENUM_PTRS_END
  66. private RELOC_PTRS_BEGIN(show_enum_reloc_ptrs) {
  67.     int i;
  68.     RELOC_PTR(gs_show_enum, pgs);
  69.     RELOC_CONST_STRING_PTR(gs_show_enum, str);
  70.     RELOC_PTR(gs_show_enum, show_gstate);
  71.     RELOC_PTR(gs_show_enum, dev_cache);
  72.     RELOC_PTR(gs_show_enum, dev_cache2);
  73.     RELOC_PTR(gs_show_enum, dev_null);
  74.     for ( i = 0; i <= eptr->fstack.depth; i++ )
  75.       RELOC_PTR(gs_show_enum, fstack.items[i].font);
  76. } RELOC_PTRS_END
  77. #undef eptr
  78.  
  79. /* Forward declarations */
  80. private int continue_kshow(P1(gs_show_enum *));
  81. private int continue_show(P1(gs_show_enum *));
  82. private int continue_show_update(P1(gs_show_enum *));
  83. private int show_setup(P4(gs_show_enum *, gs_state *, const char *, bool));
  84. private void show_set_scale(P1(gs_show_enum *));
  85. private int show_cache_setup(P1(gs_show_enum *));
  86. private int show_state_setup(P1(gs_show_enum *));
  87. private int show_origin_setup(P4(gs_state *, fixed, fixed, gs_char_path_mode));
  88. private int stringwidth_setup(P3(gs_show_enum *, gs_state *, const char *));
  89.  
  90. /* Print the ctm if debugging */
  91. #define print_ctm(s,pgs)\
  92.   dprintf7("[p]%sctm=[%g %g %g %g %g %g]\n", s,\
  93.        pgs->ctm.xx, pgs->ctm.xy, pgs->ctm.yx, pgs->ctm.yy,\
  94.        pgs->ctm.tx, pgs->ctm.ty)
  95.  
  96. /* ------ Font procedures ------ */
  97.  
  98. /* Dummy (ineffective) BuildChar/BuildGlyph procedure */
  99. int
  100. gs_no_build_char(gs_show_enum *penum, gs_state *pgs,
  101.   gs_font *pfont, gs_char chr, gs_glyph glyph)
  102. {    return 1;            /* failure, but not error */
  103. }
  104.  
  105. /* Dummy character encoding procedure */
  106. gs_glyph
  107. gs_no_encode_char(gs_show_enum *penum,
  108.   gs_font *pfont, gs_char *pchr)
  109. {    return gs_no_glyph;
  110. }
  111.  
  112. /* ------ String writing operators ------ */
  113.  
  114. /* Allocate a show enumerator. */
  115. gs_show_enum *
  116. gs_show_enum_alloc(gs_memory_t *mem, gs_state *pgs, client_name_t cname)
  117. {    gs_show_enum *penum =
  118.       gs_alloc_struct(mem, gs_show_enum, &st_gs_show_enum, cname);
  119.     if ( penum == 0 )
  120.       return 0;
  121.     /* Initialize pointers for GC */
  122.     penum->pgs = pgs;
  123.     penum->str.data = 0;
  124.     penum->str.size = 0;
  125.     penum->dev_cache = 0;
  126.     penum->dev_cache2 = 0;
  127.     penum->dev_null = 0;
  128.     penum->fstack.depth = -1;
  129.     return penum;
  130. }
  131.  
  132. /* Free the contents of a show enumerator. */
  133. void
  134. gs_show_enum_release(gs_show_enum *penum, gs_memory_t *emem)
  135. {    gs_state *pgs = penum->pgs;
  136.     gs_memory_t *mem = pgs->memory;
  137.  
  138.     penum->cc = 0;
  139.     if ( penum->dev_cache2 != 0 )
  140.       {    gs_free_object(mem, penum->dev_cache2,
  141.                    "gs_show_enum_release(dev_cache2)");
  142.         penum->dev_cache2 = 0;
  143.       }
  144.     if ( penum->dev_cache != 0 )
  145.       {    gs_free_object(mem, penum->dev_cache,
  146.                    "gs_show_enum_release(dev_cache)");
  147.         penum->dev_cache = 0;
  148.       }
  149.     if ( penum->dev_null != 0 )
  150.       {    gs_free_object(mem, penum->dev_null,
  151.                    "gs_show_enum_release(dev_null)");
  152.         penum->dev_null = 0;
  153.       }
  154.     if ( emem != 0 )
  155.       gs_free_object(emem, penum, "gs_show_enum_release(enum)");
  156. }
  157.  
  158. /* Setup macros for show operators */
  159. #define setup_show_n()\
  160.   penum->str.size = size
  161. #define setup_a()\
  162.   penum->add = true, penum->ax = ax, penum->ay = ay,\
  163.   penum->slow_show = true
  164. #define setup_width()\
  165.   penum->wchr = chr, penum->wcx = cx, penum->wcy = cy,\
  166.   penum->slow_show = true
  167.  
  168. /* show[_n] */
  169. int
  170. gs_show_n_init(register gs_show_enum *penum,
  171.    gs_state *pgs, const char *str, uint size)
  172. {    setup_show_n();
  173.     penum->slow_show = false;
  174.     return show_setup(penum, pgs, str, true);
  175. }
  176. int
  177. gs_show_init(gs_show_enum *penum, gs_state *pgs, const char *str)
  178. {    return gs_show_n_init(penum, pgs, str, strlen(str));
  179. }
  180.  
  181. /* ashow[_n] */
  182. int
  183. gs_ashow_n_init(register gs_show_enum *penum,
  184.   gs_state *pgs, floatp ax, floatp ay, const char *str, uint size)
  185. {    int code;
  186.     setup_show_n();
  187.     code = show_setup(penum, pgs, str, true);
  188.     setup_a();
  189.     return code;
  190. }
  191. int
  192. gs_ashow_init(gs_show_enum *penum,
  193.   gs_state *pgs, floatp ax, floatp ay, const char *str)
  194. {    return gs_ashow_n_init(penum, pgs, ax, ay, str, strlen(str));
  195. }
  196.  
  197. /* widthshow[_n] */
  198. int
  199. gs_widthshow_n_init(register gs_show_enum *penum,
  200.   gs_state *pgs, floatp cx, floatp cy, gs_char chr, const char *str, uint size)
  201. {    int code;
  202.     setup_show_n();
  203.     code = show_setup(penum, pgs, str, true);
  204.     setup_width();
  205.     return code;
  206. }
  207. int
  208. gs_widthshow_init(gs_show_enum *penum,
  209.   gs_state *pgs, floatp cx, floatp cy, gs_char chr, const char *str)
  210. {    return gs_widthshow_n_init(penum, pgs, cx, cy, chr, str, strlen(str));
  211. }
  212.  
  213. /* awidthshow[_n] */
  214. int
  215. gs_awidthshow_n_init(register gs_show_enum *penum,
  216.   gs_state *pgs, floatp cx, floatp cy, gs_char chr, floatp ax, floatp ay,
  217.   const char *str, uint size)
  218. {    int code;
  219.     setup_show_n();
  220.     code = show_setup(penum, pgs, str, true);
  221.     setup_a();
  222.     setup_width();
  223.     return code;
  224. }
  225. int
  226. gs_awidthshow_init(gs_show_enum *penum,
  227.   gs_state *pgs, floatp cx, floatp cy, gs_char chr, floatp ax, floatp ay,
  228.   const char *str)
  229. {    return gs_awidthshow_n_init(penum, pgs, cx, cy, chr, ax, ay,
  230.                     str, strlen(str));
  231. }
  232.  
  233. /* kshow[_n] */
  234. int
  235. gs_kshow_n_init(register gs_show_enum *penum,
  236.   gs_state *pgs, const char *str, uint size)
  237. {    int code;
  238.     if ( pgs->font->FontType == ft_composite)
  239.       return_error(gs_error_invalidfont);
  240.     setup_show_n();
  241.     code = show_setup(penum, pgs, str, true);
  242.     penum->do_kern = 1;
  243.     penum->slow_show = true;
  244.     return code;
  245. }
  246. int
  247. gs_kshow_init(gs_show_enum *penum, gs_state *pgs, const char *str)
  248. {    return gs_kshow_n_init(penum, pgs, str, strlen(str));
  249. }
  250.  
  251. /* xyshow[_n] */
  252. int
  253. gs_xyshow_n_init(register gs_show_enum *penum,
  254.    gs_state *pgs, const char *str, uint size)
  255. {    int code;
  256.     setup_show_n();
  257.     code = show_setup(penum, pgs, str, true);
  258.     penum->do_kern = -1;
  259.     penum->slow_show = true;
  260.     return code;
  261. }
  262. int
  263. gs_xyshow_init(gs_show_enum *penum, gs_state *pgs, const char *str)
  264. {    return gs_xyshow_n_init(penum, pgs, str, strlen(str));
  265. }
  266.  
  267. /* glyphshow */
  268. private int
  269. setup_glyph(P3(gs_show_enum *, gs_state *, gs_glyph));
  270. private font_proc_encode_char(gs_glyphshow_encode_char);
  271. int
  272. gs_glyphshow_init(gs_show_enum *penum, gs_state *pgs, gs_glyph glyph)
  273. {    return setup_glyph(penum, pgs, glyph);
  274. }
  275. int
  276. gs_glyphpath_init(gs_show_enum *penum, gs_state *pgs, gs_glyph glyph,
  277.   bool stroke_path)
  278. {    int code = setup_glyph(penum, pgs, glyph);
  279.     penum->charpath_flag =
  280.       (stroke_path ? cpm_true_charpath : cpm_false_charpath);
  281.     penum->can_cache = -1;
  282.     if_debug1('k', "[k]glyphpath, can_cache=%d", penum->can_cache);
  283.     return code;
  284. }
  285. private int
  286. setup_glyph(gs_show_enum *penum, gs_state *pgs, gs_glyph glyph)
  287. {    int code;
  288.     if ( pgs->font->FontType == ft_composite)
  289.       return_error(gs_error_invalidfont);
  290.     penum->str.size = 1;
  291.     penum->slow_show = false;
  292.     code = show_setup(penum, pgs, "\000", true); /* arbitrary char */
  293.     penum->current_glyph = glyph;
  294.     penum->encode_char = gs_glyphshow_encode_char;
  295.     return code;
  296. }
  297. private gs_glyph
  298. gs_glyphshow_encode_char(gs_show_enum *penum, gs_font *pfont, gs_char *pchr)
  299. {    /* We just nil out the character, and return the pre-loaded glyph. */
  300.     *pchr = gs_no_char;
  301.     return penum->current_glyph;
  302. }
  303.  
  304. /* ------ Related operators ------ */
  305.  
  306. /* cshow[_n] */
  307. int
  308. gs_cshow_n_init(register gs_show_enum *penum,
  309.    gs_state *pgs, const char *str, uint size)
  310. {    int code;
  311.     setup_show_n();
  312.     code = show_setup(penum, pgs, str, false);
  313.     penum->do_kern = -1;
  314.     penum->stringwidth_flag = -1;
  315.     penum->slow_show = true;
  316.     return code;
  317. }
  318. int
  319. gs_cshow_init(gs_show_enum *penum, gs_state *pgs, const char *str)
  320. {    return gs_cshow_n_init(penum, pgs, str, strlen(str));
  321. }
  322.  
  323. /* stringwidth[_n] */
  324. int
  325. gs_stringwidth_n_init(gs_show_enum *penum, gs_state *pgs, const char *str, uint size)
  326. {    setup_show_n();
  327.     return stringwidth_setup(penum, pgs, str);
  328. }
  329. int
  330. gs_stringwidth_init(gs_show_enum *penum, gs_state *pgs, const char *str)
  331. {    return gs_stringwidth_n_init(penum, pgs, str, strlen(str));
  332. }
  333.  
  334. /* Common code for stringwidth[_n] */
  335. private int
  336. stringwidth_setup(gs_show_enum *penum, gs_state *pgs, const char *str)
  337. {    int code =
  338.       (penum->slow_show = false, show_setup(penum, pgs, str, false));
  339.     gs_memory_t *mem = pgs->memory;
  340.     gx_device_null *dev_null;
  341.     if ( code < 0 )
  342.       return code;
  343.     dev_null = gs_alloc_struct(mem, gx_device_null, &st_device_null,
  344.                    "stringwidth_setup(dev_null)");
  345.     if ( dev_null == 0 )
  346.       return_error(gs_error_VMerror);
  347.     penum->stringwidth_flag = 1;
  348.     /* Do an extra gsave and suppress output */
  349.     if ( (code = gs_gsave(pgs)) < 0 )
  350.       return code;
  351.     penum->level = pgs->level;    /* for level check in show_update */
  352.     /* Set up a null device that forwards xfont requests properly. */
  353.     gs_make_null_device(dev_null, mem);
  354.     dev_null->target = gs_currentdevice_inline(pgs);
  355.     pgs->device = (gx_device *)dev_null;
  356.     pgs->ctm_default_set = false;
  357.     penum->dev_null = dev_null;
  358.     /* Establish an arbitrary translation and current point. */
  359.     gs_newpath(pgs);
  360.     gx_translate_to_fixed(pgs, fixed_0, fixed_0);
  361.     return gx_path_add_point(pgs->path, fixed_0, fixed_0);
  362. }
  363.  
  364. /* charpath[_n] */
  365. int
  366. gs_charpath_n_init(gs_show_enum *penum, gs_state *pgs,
  367.   const char *str, uint size, bool stroke_path)
  368. {    int code;
  369.     setup_show_n();
  370.     code = show_setup(penum, pgs, str, false);
  371.     penum->charpath_flag =
  372.       (stroke_path ? cpm_true_charpath : cpm_false_charpath);
  373.     penum->can_cache = -1;
  374.     if_debug1('k', "[k]charpath, can_cache=%d", penum->can_cache);
  375.     return code;
  376. }
  377. int
  378. gs_charpath_init(gs_show_enum *penum, gs_state *pgs,
  379.   const char *str, bool stroke_path)
  380. {    return gs_charpath_n_init(penum, pgs, str, strlen(str), stroke_path);
  381. }
  382.  
  383. /* charboxpath[_n] */
  384. int
  385. gs_charboxpath_n_init(gs_show_enum *penum, gs_state *pgs,
  386.   const char *str, uint size, bool use_boxes)
  387. {    int code;
  388.     setup_show_n();
  389.     code = show_setup(penum, pgs, str, false);
  390.     penum->charpath_flag =
  391.       (use_boxes ? cpm_true_charboxpath : cpm_false_charboxpath);
  392.     penum->can_cache = 0;        /* different from charpath! */
  393.     if_debug1('k', "[k]charboxpath, can_cache=%d", penum->can_cache);
  394.     return code;
  395. }
  396. int
  397. gs_charboxpath_init(gs_show_enum *penum, gs_state *pgs,
  398.   const char *str, bool stroke_path)
  399. {    return gs_charboxpath_n_init(penum, pgs, str, strlen(str),
  400.                      stroke_path);
  401. }
  402.  
  403. /* ------ Width/cache operators ------ */
  404.  
  405. private int set_cache_device(P3(gs_show_enum *, gs_state *,
  406.   const float * /*[4]*/));
  407.  
  408. /* setcachedevice */
  409. /* The elements of pw are: wx, wy, llx, lly, urx, ury. */
  410. /* Note that this returns 1 if we just set up the cache device. */
  411. int
  412. gs_setcachedevice(gs_show_enum *penum, gs_state *pgs, const float *pw)
  413. {    int code = gs_setcharwidth(penum, pgs, pw[0], pw[1]);    /* default is don't cache */
  414.  
  415.     if ( code < 0 )
  416.       return code;
  417.     return set_cache_device(penum, pgs, pw + 2);
  418. }
  419.  
  420. /* setcachedevice2 */
  421. /* The elements of pw2 are: w0x, w0y, llx, lly, urx, ury, w1x, w1y, vx, vy. */
  422. /* Note that this returns 1 if we just set up the cache device. */
  423. int
  424. gs_setcachedevice2(gs_show_enum *penum, gs_state *pgs, const float *pw2)
  425. {    int code;
  426.  
  427.     if ( gs_rootfont(pgs)->WMode )
  428.     {    float vx = pw2[8], vy = pw2[9];
  429.         gs_fixed_point pvxy, dvxy;
  430.         cached_char *cc;
  431.         if ( (code = gs_point_transform2fixed(&pgs->ctm, -vx, -vy, &pvxy)) < 0 ||
  432.              (code = gs_distance_transform2fixed(&pgs->ctm, vx, vy, &dvxy)) < 0 ||
  433.              (code = gs_setcharwidth(penum, pgs, pw2[6], pw2[7])) < 0
  434.            )
  435.           return code;
  436.         /* Adjust the origin by (vx, vy). */
  437.         gx_translate_to_fixed(pgs, pvxy.x, pvxy.y);
  438.         code = set_cache_device(penum, pgs, pw2 + 2);
  439.         if ( code != 1 )
  440.           return code;
  441.         /* Adjust the character origin too. */
  442.         cc = penum->cc;
  443.         cc->offset.x += dvxy.x;
  444.         cc->offset.y += dvxy.y;
  445.     }
  446.     else
  447.     {    code = gs_setcharwidth(penum, pgs, pw2[0], pw2[1]);
  448.         if ( code < 0 )
  449.           return code;
  450.         code = set_cache_device(penum, pgs, pw2 + 2);
  451.     }
  452.     return code;
  453. }
  454.  
  455. /* Set up the cache device if relevant. */
  456. /* Return 1 if we just set up a cache device. */
  457. /* Used by setcachedevice and setcachedevice2. */
  458. /* The elements of pb are: llx, lly, urx, ury. */
  459. private int
  460. set_cache_device(register gs_show_enum *penum, gs_state *pgs, const float *pb)
  461. {    float llx = pb[0], lly = pb[1], urx = pb[2], ury = pb[3];
  462.     gs_glyph glyph;
  463.     /* See if we want to cache this character. */
  464.     if ( pgs->in_cachedevice )        /* no recursion! */
  465.       return 0;
  466.     pgs->in_cachedevice = 1;    /* disable color/gray/image operators */
  467.     /* We can only use the cache if we know the glyph. */
  468.     glyph = gs_show_current_glyph(penum);
  469.     if ( glyph == gs_no_glyph )
  470.       return 0;
  471.     /* We can only use the cache if ctm is unchanged */
  472.     /* (aside from a possible translation). */
  473.     if ( penum->can_cache <= 0 || !pgs->char_tm_valid )
  474.     {    if_debug2('k', "[k]no cache: can_cache=%d, char_tm_valid=%d\n",
  475.               penum->can_cache, (int)pgs->char_tm_valid);
  476.         return 0;
  477.     }
  478.        {    const gs_font *pfont = pgs->font;
  479.         gs_font_dir *dir = pfont->dir;
  480.         gx_device *dev = gs_currentdevice_inline(pgs);
  481.         int alpha_bits =
  482.           (*dev_proc(dev, get_alpha_bits))(dev, go_text);
  483.         gs_log2_scale_point log2_scale;
  484.         static const fixed max_cdim[3] = {
  485. #define max_cd(n)\
  486.   (fixed_1 << (arch_sizeof_short * 8 - n)) - (fixed_1 >> n) * 3
  487.             max_cd(0), max_cd(1), max_cd(2)
  488. #undef max_cd
  489.         };
  490.         ushort iwidth, iheight;
  491.         cached_char *cc;
  492.         gs_fixed_rect clip_box;
  493.         int code;
  494.         /* Compute the bounding box of the transformed character. */
  495.         /* Since we accept arbitrary transformations, the extrema */
  496.         /* may occur in any order; however, we can save some work */
  497.         /* by observing that opposite corners before transforming */
  498.         /* are still opposite afterwards. */
  499.         gs_fixed_point cll, clr, cul, cur, cdim;
  500.  
  501.         if ( (code = gs_distance_transform2fixed(&pgs->ctm, llx, lly, &cll)) < 0 ||
  502.              (code = gs_distance_transform2fixed(&pgs->ctm, llx, ury, &clr)) < 0 ||
  503.              (code = gs_distance_transform2fixed(&pgs->ctm, urx, lly, &cul)) < 0 ||
  504.              (code = gs_distance_transform2fixed(&pgs->ctm, urx, ury, &cur)) < 0
  505.            )
  506.           return code;
  507.         { fixed ctemp;
  508. #define swap(a, b) ctemp = a, a = b, b = ctemp
  509. #define make_min(a, b) if ( (a) > (b) ) swap(a, b)
  510.           make_min(cll.x, cur.x);
  511.           make_min(cll.y, cur.y);
  512.           make_min(clr.x, cul.x);
  513.           make_min(clr.y, cul.y);
  514. #undef make_min
  515. #undef swap
  516.         }
  517.         /* Now take advantage of symmetry. */
  518.         if ( clr.x < cll.x ) cll.x = clr.x, cur.x = cul.x;
  519.         if ( clr.y < cll.y ) cll.y = clr.y, cur.y = cul.y;
  520.         /* Now cll and cur are the extrema of the box. */
  521.         cdim.x = cur.x - cll.x;
  522.         cdim.y = cur.y - cll.y;
  523.         show_set_scale(penum);
  524.         log2_scale.x = penum->log2_suggested_scale.x;
  525.         log2_scale.y = penum->log2_suggested_scale.y;
  526. #ifdef DEBUG
  527. if ( gs_debug_c('k') )
  528.    {    dprintf6("[k]cbox=[%g %g %g %g] scale=%dx%d\n",
  529.          fixed2float(cll.x), fixed2float(cll.y),
  530.          fixed2float(cur.x), fixed2float(cur.y),
  531.          1 << log2_scale.x, 1 << log2_scale.y);
  532.     print_ctm("  ", pgs);
  533.    }
  534. #endif
  535.         /*
  536.          * If the device wants anti-aliased text,
  537.          * increase the sampling scale to ensure that
  538.          * if we want N bits of alpha, we generate
  539.          * at least 2^N sampled bits per pixel.
  540.          */
  541.         if ( alpha_bits > 1 )
  542.           {    int more_bits =
  543.               alpha_bits - (log2_scale.x + log2_scale.y);
  544.             if ( more_bits > 0 )
  545.               {    if (log2_scale.x <= log2_scale.y) 
  546.                   { log2_scale.x += (more_bits + 1) >> 1;
  547.                     log2_scale.y += more_bits >> 1;
  548.                   }
  549.                 else
  550.                   { log2_scale.x += more_bits >> 1;
  551.                     log2_scale.y += (more_bits + 1) >> 1;
  552.                   }
  553.               }
  554.           }
  555.         else
  556. #if OVERSAMPLE
  557.           if ( pfont->PaintType == 2 )
  558. #endif
  559.           {    /* Don't oversample artificially stroked fonts. */
  560.             log2_scale.x = log2_scale.y = 0;
  561.           }
  562.         if ( cdim.x > max_cdim[log2_scale.x] ||
  563.              cdim.y > max_cdim[log2_scale.y]
  564.            )
  565.           return 0;        /* much too big */
  566.         iwidth = ((ushort)fixed2int_var(cdim.x)  + 2) << log2_scale.x;
  567.         iheight = ((ushort)fixed2int_var(cdim.y) + 2) << log2_scale.y;
  568.         if_debug3('k', "[k]iwidth=%u iheight=%u dev_cache %s\n",
  569.               (uint)iwidth, (uint)iheight,
  570.               (penum->dev_cache == 0 ? "not set" : "set"));
  571.         if ( penum->dev_cache == 0 )
  572.           {    code = show_cache_setup(penum);
  573.             if ( code < 0 )
  574.               return code;
  575.           }
  576.         /*
  577.          * If we're oversampling (i.e., the temporary bitmap is
  578.          * larger than the final monobit or alpha array) and the
  579.          * temporary bitmap is large, use incremental conversion
  580.          * from oversampled bitmap strips to alpha values instead of
  581.          * full oversampling with compression at the end.
  582.          */
  583.         cc = gx_alloc_char_bits(dir, penum->dev_cache,
  584.             (iwidth > MAX_TEMP_BITMAP_BITS / iheight &&
  585.              (1 << (log2_scale.x + log2_scale.y)) > alpha_bits ?
  586.              penum->dev_cache2 : NULL),
  587.             iwidth, iheight, &log2_scale, alpha_bits);
  588.         if ( cc == 0 )
  589.           return 0;    /* too big for cache */
  590.         /* The mins handle transposed coordinate systems.... */
  591.         /* Truncate the offsets to avoid artifacts later. */
  592.         cc->offset.x = fixed_ceiling(-cll.x);
  593.         cc->offset.y = fixed_ceiling(-cll.y);
  594.         if_debug4('k', "[k]width=%u, height=%u, offset=[%g %g]\n",
  595.               (uint)iwidth, (uint)iheight,
  596.               fixed2float(cc->offset.x),
  597.               fixed2float(cc->offset.y));
  598.         if ( (code = gs_gsave(pgs)) < 0 )
  599.            {    gx_free_cached_char(dir, cc);
  600.             return code;
  601.            }
  602.         /* Nothing can go wrong now.... */
  603.         penum->cc = cc;
  604.         cc->code = glyph;
  605.         cc->wmode = gs_rootfont(pgs)->WMode;
  606.         cc->wxy = penum->wxy;
  607.         /* Install the device */
  608.         pgs->device = (gx_device *)penum->dev_cache;
  609.         pgs->ctm_default_set = false;
  610.         /* Adjust the transformation in the graphics context */
  611.         /* so that the character lines up with the cache. */
  612.         gx_translate_to_fixed(pgs,
  613.                       cc->offset.x << log2_scale.x,
  614.                       cc->offset.y << log2_scale.y);
  615.         if ( (log2_scale.x | log2_scale.y) != 0 )
  616.             gx_scale_char_matrix(pgs, 1 << log2_scale.x,
  617.                          1 << log2_scale.y);
  618.         /* Set the initial matrix for the cache device. */
  619.         penum->dev_cache->initial_matrix = ctm_only(pgs);
  620.         /* Set the oversampling factor. */
  621.         penum->log2_current_scale.x = log2_scale.x;
  622.         penum->log2_current_scale.y = log2_scale.y;
  623.         /* Reset the clipping path to match the metrics. */
  624.         clip_box.p.x = clip_box.p.y = 0;
  625.         clip_box.q.x = int2fixed(iwidth);
  626.         clip_box.q.y = int2fixed(iheight);
  627.         if ( (code = gx_clip_to_rectangle(pgs, &clip_box)) < 0 )
  628.           return code;
  629.         gx_set_device_color_1(pgs);    /* write 1's */
  630.         pgs->in_cachedevice = 2;    /* we are caching */
  631.        }
  632.     penum->width_status = sws_cache;
  633.     return 1;
  634. }
  635.  
  636. /* setcharwidth */
  637. /* Note that this returns 1 if the current show operation is */
  638. /* non-displaying (stringwidth or cshow). */
  639. int
  640. gs_setcharwidth(register gs_show_enum *penum, gs_state *pgs,
  641.   floatp wx, floatp wy)
  642. {    int code;
  643.     if ( penum->width_status != sws_none )
  644.       return_error(gs_error_undefined);
  645.     if ( (code = gs_distance_transform2fixed(&pgs->ctm, wx, wy, &penum->wxy)) < 0 )
  646.       return code;
  647.     /* Check whether we're setting the scalable width */
  648.     /* for a cached xfont character. */
  649.     if ( penum->cc != 0 )
  650.       {    penum->cc->wxy = penum->wxy;
  651.         penum->width_status = sws_cache_width_only;
  652.       }
  653.     else
  654.       {    penum->width_status = sws_no_cache;
  655.       }
  656.     return (penum->stringwidth_flag != 0 ? 1 : 0);
  657. }
  658.  
  659. /* ------ Enumerator ------ */
  660.  
  661. /* Do the next step of a show (or stringwidth) operation */
  662. int
  663. gs_show_next(gs_show_enum *penum)
  664. {    return (*penum->continue_proc)(penum);
  665. }
  666.  
  667. /* Continuation procedures */
  668. private int show_update(P1(gs_show_enum *penum));
  669. private int show_move(P1(gs_show_enum *penum));
  670. private int show_proceed(P1(gs_show_enum *penum));
  671. private int show_finish(P1(gs_show_enum *penum));
  672. private int
  673. continue_show_update(register gs_show_enum *penum)
  674. {    int code = show_update(penum);
  675.     if ( code < 0 )
  676.       return code;
  677.     code = show_move(penum);
  678.     if ( code != 0 )
  679.       return code;
  680.     return show_proceed(penum);
  681. }
  682. private int
  683. continue_show(register gs_show_enum *penum)
  684. {    return show_proceed(penum);
  685. }
  686. /* For kshow, the CTM or font may have changed, so we have to reestablish */
  687. /* the cached values in the enumerator. */
  688. private int
  689. continue_kshow(register gs_show_enum *penum)
  690. {    int code = show_state_setup(penum);
  691.     if ( code < 0 )
  692.       return code;
  693.     return show_proceed(penum);
  694. }
  695.  
  696. /* Update position */
  697. private int
  698. show_update(register gs_show_enum *penum)
  699. {    register gs_state *pgs = penum->pgs;
  700.     cached_char *cc = penum->cc;
  701.     int code;
  702.     /* Update position for last character */
  703.     switch ( penum->width_status )
  704.        {
  705.     case sws_none:
  706.         /* Adobe interpreters assume a character width of 0, */
  707.         /* even though the documentation says this is an error.... */
  708.         penum->wxy.x = penum->wxy.y = 0;
  709.         break;
  710.     case sws_cache:
  711.         /* Finish installing the cache entry. */
  712.         /* If the BuildChar/BuildGlyph procedure did a save and a */
  713.         /* restore, it already undid the gsave in setcachedevice. */
  714.         /* We have to check for this by comparing levels. */
  715.         switch ( pgs->level - penum->level )
  716.            {
  717.         default:
  718.             return_error(gs_error_invalidfont);    /* WRONG */
  719.         case 2:
  720.             code = gs_grestore(pgs);
  721.             if ( code < 0 )
  722.               return code;
  723.         case 1:
  724.             ;
  725.            }
  726.         gx_add_cached_char(pgs->font->dir, penum->dev_cache,
  727.                    cc, gx_lookup_fm_pair(pgs->font, pgs),
  728.                    &penum->log2_current_scale);
  729.         if ( penum->stringwidth_flag != 0 ||
  730.              penum->charpath_flag != cpm_show
  731.            )
  732.           break;
  733.         /* falls through */
  734.     case sws_cache_width_only:
  735.         /* Copy the bits to the real output device. */
  736.         code = gs_grestore(pgs);
  737.         if ( code < 0 )
  738.           return code;
  739.         code = gs_state_color_load(pgs);
  740.         if ( code < 0 )
  741.           return code;
  742.         return gx_image_cached_char(penum, cc);
  743.     case sws_no_cache:
  744.         ;
  745.        }
  746.     if ( penum->charpath_flag != cpm_show )
  747.     {    /* Move back to the character origin, so that */
  748.         /* show_move will get us to the right place. */
  749.         code = gx_path_add_point(pgs->show_gstate->path,
  750.                      penum->origin.x, penum->origin.y);
  751.         if ( code < 0 )
  752.           return code;
  753.     }
  754.     return gs_grestore(pgs);
  755. }
  756.  
  757. /* Move to next character */
  758. private int
  759. show_fast_move(gs_state *pgs, gs_fixed_point *pwxy)
  760. {    int code = gx_path_add_rel_point_inline(pgs->path, pwxy->x, pwxy->y);
  761.     /* If the current position is out of range, don't try to move. */
  762.     if ( code == gs_error_limitcheck && pgs->clamp_coordinates )
  763.       code = 0;
  764.     return code;
  765. }
  766. private int
  767. show_move(register gs_show_enum *penum)
  768. {    register gs_state *pgs = penum->pgs;
  769.     if ( penum->do_kern < 0 )
  770.     {    /* xyshow or cshow */
  771.         penum->continue_proc = continue_show;
  772.         return gs_show_move;
  773.     }
  774.     if ( penum->add )
  775.         gs_rmoveto(pgs, penum->ax, penum->ay);
  776.     if ( penum->wchr != gs_no_char )
  777.     {    gs_char chr = penum->current_char;
  778.         int fdepth = penum->fstack.depth;
  779.         if ( fdepth > 0 )
  780.         {    /* Add in the shifted font number. */
  781.             uint fidx = penum->fstack.items[fdepth].index;
  782.             switch ( ((gs_font_type0 *)(penum->fstack.items[fdepth - 1].font))->data.FMapType )
  783.             {
  784.             case fmap_1_7:
  785.             case fmap_9_7:
  786.                 chr += fidx << 7;
  787.                 break;
  788.             default:
  789.                 chr += fidx << 8;
  790.             }
  791.         }
  792.         if ( chr == penum->wchr )
  793.             gs_rmoveto(pgs, penum->wcx, penum->wcy);
  794.     }
  795.     /* wxy is in device coordinates */
  796.        {    int code = show_fast_move(pgs, &penum->wxy);
  797.         if ( code < 0 )
  798.           return code;
  799.        }
  800.     /* Check for kerning, but not on the last character. */
  801.     if ( penum->do_kern && penum->index < penum->str.size )
  802.        {    penum->continue_proc = continue_kshow;
  803.         return gs_show_kern;
  804.        }
  805.     return 0;
  806. }
  807. /* Process next character */
  808. private int
  809. show_proceed(register gs_show_enum *penum)
  810. {    register gs_state *pgs = penum->pgs;
  811.     gs_font *pfont;
  812.     cached_fm_pair *pair = 0;
  813.     gs_font *rfont = gs_rootfont(pgs);
  814.     int wmode = rfont->WMode;
  815.     font_proc_next_char((*next_char)) = rfont->procs.next_char;
  816.     font_proc_next_glyph((*next_glyph)) = rfont->procs.next_glyph;
  817. #define next_char_glyph(penum, pchr, pglyph)\
  818.   (next_char == 0 ? (*next_glyph)(penum, pchr, pglyph) :\
  819.    (*(pglyph) = gs_no_glyph, (*next_char)(penum, pchr)))
  820.     gs_char chr;
  821.     gs_glyph glyph;
  822.     int code;
  823.     cached_char *cc;
  824.     gx_device *dev = gs_currentdevice_inline(pgs);
  825.     int alpha_bits = (*dev_proc(dev, get_alpha_bits))(dev, go_text);
  826.  
  827.     if ( penum->charpath_flag == cpm_show && !penum->stringwidth_flag )
  828.       {    code = gs_state_color_load(pgs);
  829.         if ( code < 0 )
  830.           return code;
  831.       }
  832. more:    /* Proceed to next character */
  833.     pfont = (penum->fstack.depth < 0 ? pgs->font :
  834.          penum->fstack.items[penum->fstack.depth].font);
  835.     /* can_cache >= 0 allows us to use cached characters, */
  836.     /* even if we can't make new cache entries. */
  837.     if ( penum->can_cache >= 0 )
  838.     {    /* Loop with cache */
  839.         for ( ; ; )
  840.         {   switch ( (code = next_char_glyph(penum, &chr, &glyph)) )
  841.             {
  842.             default:            /* error */
  843.             return code;
  844.             case 2:                /* done */
  845.             return show_finish(penum);
  846.             case 1:                /* font change */
  847.             pfont = penum->fstack.items[penum->fstack.depth].font;
  848.             pgs->char_tm_valid = false;
  849.             show_state_setup(penum);
  850.             pair = 0;
  851.             /* falls through */
  852.             case 0:                /* plain char */
  853.             /*
  854.              * We don't need to set penum->current_char in the
  855.              * normal cases, but it's needed for widthshow,
  856.              * kshow, and one strange client, so we may as well
  857.              * do it here.
  858.              */
  859.             penum->current_char = chr;
  860.             if ( glyph == gs_no_glyph )
  861.               { glyph = (*penum->encode_char)(penum, pfont, &chr);
  862.                 penum->current_char = chr;
  863.                 if ( glyph == gs_no_glyph )
  864.                   { cc = 0;
  865.                 goto no_cache;
  866.                   }
  867.               }
  868.             if ( pair == 0 )
  869.               pair = gx_lookup_fm_pair(pfont, pgs);
  870.             cc = gx_lookup_cached_char(pfont, pair, glyph, wmode,
  871.                            alpha_bits);
  872.             if ( cc == 0 )
  873.               { /* Character is not in cache. */
  874.                 /* If possible, try for an xfont before */
  875.                 /* rendering from the outline. */
  876.                 if ( pfont->ExactSize == fbit_use_outlines ||
  877.                  pfont->PaintType == 2
  878.                    )
  879.                   goto no_cache;
  880.                 if ( pfont->BitmapWidths )
  881.                   { cc = gx_lookup_xfont_char(pgs, pair, chr,
  882.                     glyph, &pfont->procs.callbacks, wmode);
  883.                 if ( cc == 0 )
  884.                   goto no_cache;
  885.                   }
  886.                 else
  887.                   { if ( penum->stringwidth_flag != 0 ||
  888.                      penum->charpath_flag != cpm_show
  889.                    )
  890.                   goto no_cache;
  891.                 /* We might have an xfont, but we still */
  892.                 /* want the scalable widths. */
  893.                 cc = gx_lookup_xfont_char(pgs, pair, chr,
  894.                     glyph, &pfont->procs.callbacks, wmode);
  895.                 /* Render up to the point of */
  896.                 /* setcharwidth or setcachedevice, */
  897.                 /* just as for stringwidth. */
  898.                 /* This is the only case in which we can */
  899.                 /* to go no_cache with cc != 0. */
  900.                 goto no_cache;
  901.                   }
  902.               }
  903.             /* Character is in cache. */
  904.             /* We might be doing .charboxpath or stringwidth; */
  905.             /* check for these now. */
  906.             if ( penum->charpath_flag != cpm_show )
  907.               { /* This is .charboxpath.  Get the bounding box */
  908.                 /* and append it to a path. */
  909.                 gx_path box_path;
  910.                 gs_fixed_point pt;
  911.                 fixed llx, lly, urx, ury;
  912.                 code = gx_path_current_point(pgs->path, &pt);
  913.                 if ( code < 0 )
  914.                   return code;
  915.                 llx = fixed_rounded(pt.x - cc->offset.x) +
  916.                   int2fixed(penum->ftx);
  917.                 lly = fixed_rounded(pt.y - cc->offset.y) +
  918.                   int2fixed(penum->fty);
  919.                 urx = llx + int2fixed(cc->width),
  920.                 ury = lly + int2fixed(cc->height);
  921.                 gx_path_init(&box_path, pgs->memory);
  922.                 code =
  923.                   gx_path_add_rectangle(&box_path, llx, lly,
  924.                             urx, ury);
  925.                 if ( code >= 0 )
  926.                   code =
  927.                 gx_path_add_char_path(pgs->show_gstate->path,
  928.                               &box_path,
  929.                               penum->charpath_flag);
  930.                 if ( code >= 0 )
  931.                   code = gx_path_add_point(pgs->path, pt.x, pt.y);
  932.                 gx_path_release(&box_path);
  933.                 if ( code < 0 )
  934.                   return code;
  935.               }
  936.             else if ( !penum->stringwidth_flag )
  937.               { code = gx_image_cached_char(penum, cc);
  938.                 if ( code < 0 )
  939.                   return code;
  940.                 else if ( code > 0 )
  941.                   { cc = 0;
  942.                 goto no_cache;
  943.                   }
  944.               }
  945.             if ( penum->slow_show )
  946.               { /* Split up the assignment so that the */
  947.                 /* Watcom compiler won't reserve esi/edi. */
  948.                 penum->wxy.x = cc->wxy.x;
  949.                 penum->wxy.y = cc->wxy.y;
  950.                 code = show_move(penum);
  951.               }
  952.             else
  953.               code = show_fast_move(pgs, &cc->wxy);
  954.             if ( code )
  955.               { /* Might be kshow, so store the state. */
  956.                 penum->current_glyph = glyph;
  957.                 return code;
  958.               }
  959.             }
  960.         }
  961.     }
  962.     else
  963.     {    /* Can't use cache */
  964.         switch ( (code = next_char_glyph(penum, &chr, &glyph)) )
  965.         {
  966.         default:
  967.             return code;
  968.         case 2:
  969.             return show_finish(penum);
  970.         case 1:
  971.             pfont = penum->fstack.items[penum->fstack.depth].font;
  972.             show_state_setup(penum);
  973.         case 0:
  974.             ;
  975.         }
  976.         penum->current_char = chr;
  977.         if ( glyph != gs_no_glyph )
  978.           { glyph = (*penum->encode_char)(penum, pfont, &chr);
  979.             penum->current_char = chr;
  980.           }
  981.         cc = 0;
  982.     }
  983. no_cache:
  984.     /*
  985.      * We must call the client's rendering code.  Normally,
  986.      * we only do this if the character is not cached (cc = 0);
  987.      * however, we also must do this if we have an xfont but
  988.      * are using scalable widths.  In this case, and only this case,
  989.      * we get here with cc != 0.  penum->current_char has already
  990.      * been set, but not penum->current_glyph.
  991.      */
  992.     penum->current_glyph = glyph;
  993.     if ( (code = gs_gsave(pgs)) < 0 )
  994.       return code;
  995.     /* Set the font to the current descendant font. */
  996.     pgs->font = pfont;
  997.     /* Reset the in_cachedevice flag, so that a recursive show */
  998.     /* will use the cache properly. */
  999.     pgs->in_cachedevice = 0;
  1000.     /* Reset the sampling scale. */
  1001.     penum->log2_current_scale.x = penum->log2_current_scale.y = 0;
  1002.     /* Set the charpath data in the graphics context if necessary, */
  1003.     /* so that fill and stroke will add to the path */
  1004.     /* rather than having their usual effect. */
  1005.     pgs->in_charpath = penum->charpath_flag;
  1006.     pgs->show_gstate =
  1007.       (penum->show_gstate == pgs ? pgs->saved : penum->show_gstate);
  1008.     pgs->stroke_adjust = false;        /* per specification */
  1009.        {    gs_fixed_point cpt;
  1010.         gx_path *ppath = pgs->path;
  1011.  
  1012.         if ( (code = gx_path_current_point_inline(ppath, &cpt)) < 0 )
  1013.           goto rret;
  1014.         penum->origin.x = cpt.x;
  1015.         penum->origin.y = cpt.y;
  1016.         /* Normally, char_tm is valid because of show_state_setup, */
  1017.         /* but if we're in a cshow, it may not be. */
  1018.         gs_currentcharmatrix(pgs, NULL, true);
  1019. #if 1 /*USE_FPU <= 0*/
  1020.         if ( pgs->ctm.txy_fixed_valid && pgs->char_tm.txy_fixed_valid )
  1021.           {    fixed tx = pgs->ctm.tx_fixed;
  1022.             fixed ty = pgs->ctm.ty_fixed;
  1023.  
  1024.             gs_settocharmatrix(pgs);
  1025.             cpt.x += pgs->ctm.tx_fixed - tx;
  1026.             cpt.y += pgs->ctm.ty_fixed - ty;
  1027.           }
  1028.         else
  1029. #endif
  1030.           {    double tx = pgs->ctm.tx;
  1031.             double ty = pgs->ctm.ty;
  1032.             double fpx, fpy;
  1033.  
  1034.             gs_settocharmatrix(pgs);
  1035.             fpx = fixed2float(cpt.x) + (pgs->ctm.tx - tx);
  1036.             fpy = fixed2float(cpt.y) + (pgs->ctm.ty - ty);
  1037. #define f_fits_in_fixed(f) f_fits_in_bits(f, fixed_int_bits)
  1038.             if ( !(f_fits_in_fixed(fpx) && f_fits_in_fixed(fpy)) )
  1039.               { gs_note_error(code = gs_error_limitcheck);
  1040.                 goto rret;
  1041.               }
  1042.             cpt.x = float2fixed(fpx);
  1043.             cpt.y = float2fixed(fpy);
  1044.           }
  1045.         gs_newpath(pgs);
  1046.         code = show_origin_setup(pgs, cpt.x, cpt.y,
  1047.                      penum->charpath_flag);
  1048.         if ( code < 0 )
  1049.           goto rret;
  1050.        }
  1051.     penum->width_status = sws_none;
  1052.     penum->continue_proc = continue_show_update;
  1053.     /* Try using the build procedure in the font. */
  1054.     /* < 0 means error, 0 means success, 1 means failure. */
  1055.     penum->cc = cc;        /* set this now for build procedure */
  1056.     code = (*pfont->procs.build_char)(penum, pgs, pfont, chr, glyph);
  1057.     if ( code < 0 )
  1058.       { discard(gs_note_error(code));
  1059.         goto rret;
  1060.       }
  1061.     if ( code == 0 )
  1062.        {    code = show_update(penum);
  1063.         if ( code < 0 )
  1064.           goto rret;
  1065.         /* Note that show_update does a grestore.... */
  1066.         code = show_move(penum);
  1067.         if ( code )
  1068.           return code;    /* ... so don't go to rret here. */
  1069.         goto more;
  1070.        }
  1071.     /*
  1072.      * Some BuildChar procedures do a save before the setcachedevice,
  1073.      * and a restore at the end.  If we waited to allocate the cache
  1074.      * device until the setcachedevice, we would attempt to free it
  1075.      * after the restore.  Therefore, allocate it now.
  1076.      */
  1077.     if ( penum->dev_cache == 0 )
  1078.       {    code = show_cache_setup(penum);
  1079.         if ( code < 0 )
  1080.           goto rret;
  1081.       }
  1082.     return gs_show_render;
  1083.     /* If we get an error while setting up for BuildChar, */
  1084.     /* we must undo the partial setup. */
  1085. rret:    gs_grestore(pgs);
  1086.     return code;
  1087. #undef next_char_glyph
  1088. }
  1089.  
  1090. /* Finish show or stringwidth */
  1091. private int
  1092. show_finish(gs_show_enum *penum)
  1093. {    gs_state *pgs = penum->pgs;
  1094.     int code, rcode;
  1095.  
  1096.     gs_show_enum_release(penum, NULL);
  1097.     if ( penum->stringwidth_flag <= 0 )    /* could be cshow */
  1098.       return 0;
  1099.     /* Save the accumulated width before returning, */
  1100.     /* and undo the extra gsave. */
  1101.     code = gs_currentpoint(pgs, &penum->width);
  1102.     rcode = gs_grestore(pgs);
  1103.     return (code < 0 ? code : rcode);
  1104. }
  1105.  
  1106. /* Return the current character for rendering. */
  1107. gs_char
  1108. gs_show_current_char(const gs_show_enum *penum)
  1109. {    return penum->current_char;
  1110. }
  1111.  
  1112. /* Return the current glyph for rendering. */
  1113. gs_glyph
  1114. gs_show_current_glyph(const gs_show_enum *penum)
  1115. {    return penum->current_glyph;
  1116. }
  1117.  
  1118. /* Return the width of the just-enumerated character (for cshow). */
  1119. int
  1120. gs_show_current_width(const gs_show_enum *penum, gs_point *ppt)
  1121. {    return gs_idtransform(penum->pgs,
  1122.                   fixed2float(penum->wxy.x),
  1123.                   fixed2float(penum->wxy.y), ppt);
  1124. }
  1125.  
  1126. /* Return the just-displayed character for kerning. */
  1127. gs_char
  1128. gs_kshow_previous_char(const gs_show_enum *penum)
  1129. {    return penum->current_char;
  1130. }
  1131.  
  1132. /* Return the about-to-be-displayed character for kerning. */
  1133. gs_char
  1134. gs_kshow_next_char(const gs_show_enum *penum)
  1135. {    return penum->str.data[penum->index];
  1136. }
  1137.  
  1138. /* ------ Miscellaneous accessors ------ */
  1139.  
  1140. /* Return the current font for cshow. */
  1141. gs_font *
  1142. gs_show_current_font(const gs_show_enum *penum)
  1143. {    return (penum->fstack.depth < 0 ? penum->pgs->font :
  1144.         penum->fstack.items[penum->fstack.depth].font);
  1145. }
  1146.  
  1147. /* Return the charpath mode. */
  1148. gs_char_path_mode
  1149. gs_show_in_charpath(const gs_show_enum *penum)
  1150. {    return penum->charpath_flag;
  1151. }
  1152.  
  1153. /* Return the accumulated width for stringwidth. */
  1154. void
  1155. gs_show_width(const gs_show_enum *penum, gs_point *ppt)
  1156. {    *ppt = penum->width;
  1157. }
  1158.  
  1159. /* Return true if we only need the width from the rasterizer */
  1160. /* and can short-circuit the full rendering of the character, */
  1161. /* false if we need the actual character bits. */
  1162. /* This is only meaningful just before calling gs_setcharwidth or */
  1163. /* gs_setcachedevice[2]. */
  1164. /* Note that we can't do this if the procedure has done any extra [g]saves. */
  1165. bool
  1166. gs_show_width_only(const gs_show_enum *penum)
  1167. {    /* penum->cc will be non-zero iff we are calculating */
  1168.     /* the scalable width for an xfont character. */
  1169.     return ((penum->stringwidth_flag != 0 || penum->cc != 0) &&
  1170.         penum->pgs->level == penum->level + 1);
  1171. }
  1172.  
  1173. /* ------ Internal routines ------ */
  1174.  
  1175. /* Initialize a show enumerator. */
  1176. /* Note that this does not set str.size. */
  1177. private int
  1178. show_setup(register gs_show_enum *penum, gs_state *pgs, const char *str,
  1179.   bool propagate_charpath)
  1180. {    int code;
  1181.     gs_font *pfont;
  1182.     gx_set_dev_color(pgs);
  1183.     pfont = pgs->font;
  1184.     penum->pgs = pgs;
  1185.     penum->level = pgs->level;
  1186.     penum->str.data = (const byte *)str;    /* avoid signed chars */
  1187.     penum->wchr = gs_no_char;
  1188.     penum->add = false;
  1189.     penum->do_kern = 0;
  1190.     penum->charpath_flag =
  1191.       (propagate_charpath ? pgs->in_charpath : cpm_show);
  1192.     penum->stringwidth_flag = 0;
  1193.     penum->dev_cache = 0;
  1194.     penum->dev_cache2 = 0;
  1195.     penum->dev_null = 0;
  1196.     penum->index = 0;
  1197.     penum->cc = 0;
  1198.     penum->continue_proc = continue_show;
  1199.     code = (*pfont->procs.init_fstack)(penum, pfont);
  1200.     if ( code < 0 )
  1201.       return code;
  1202.     penum->can_cache =        /* show_state_setup may reset */
  1203.       (penum->charpath_flag == cpm_show ? 1 : -1);
  1204.     code = show_state_setup(penum);
  1205.     if ( code < 0 )
  1206.       return code;
  1207.     penum->show_gstate =
  1208.       (propagate_charpath && (pgs->in_charpath != 0) ?
  1209.        pgs->show_gstate : pgs);
  1210.     return 0;
  1211. }
  1212.  
  1213. /* Initialize the gstate-derived parts of a show enumerator. */
  1214. /* We do this both when starting the show operation, */
  1215. /* and when returning from the kshow callout. */
  1216. private int
  1217. show_state_setup(gs_show_enum *penum)
  1218. {    gs_state *pgs = penum->pgs;
  1219.     const gs_font *pfont;
  1220.     if ( penum->fstack.depth <= 0 )
  1221.     {    pfont = pgs->font;
  1222.         gs_currentcharmatrix(pgs, NULL, 1); /* make char_tm valid */
  1223.     }
  1224.     else
  1225.     {    /* We have to concatenate the parent's FontMatrix as well. */
  1226.         gs_matrix mat;
  1227.         const gx_font_stack_item *pfsi =
  1228.           &penum->fstack.items[penum->fstack.depth];
  1229.         pfont = pfsi->font;
  1230.         gs_matrix_multiply(&pfont->FontMatrix,
  1231.                    &pfsi[-1].font->FontMatrix, &mat);
  1232.         gs_setcharmatrix(pgs, &mat);
  1233.     }
  1234.     if ( (penum->can_cache >= 0
  1235. #if !CACHE_ROTATED_CHARS
  1236.           &= /* no skewing or non-rectangular rotation */
  1237.           (is_fzero2(pgs->char_tm.xy, pgs->char_tm.yx) ||
  1238.            is_fzero2(pgs->char_tm.xx, pgs->char_tm.yy))
  1239. #endif
  1240.        ) )
  1241.        {    gs_fixed_rect cbox;
  1242.         gx_cpath_inner_box(pgs->clip_path, &cbox);
  1243.         /* Since characters occupy an integral number of pixels, */
  1244.         /* we can (and should) round the inner clipping box */
  1245.         /* outward rather than inward. */
  1246.         penum->ibox.p.x = fixed2int_var(cbox.p.x);
  1247.         penum->ibox.p.y = fixed2int_var(cbox.p.y);
  1248.         penum->ibox.q.x = fixed2int_var_ceiling(cbox.q.x);
  1249.         penum->ibox.q.y = fixed2int_var_ceiling(cbox.q.y);
  1250.         gx_cpath_outer_box(pgs->clip_path, &cbox);
  1251.         penum->obox.p.x = fixed2int_var(cbox.p.x);
  1252.         penum->obox.p.y = fixed2int_var(cbox.p.y);
  1253.         penum->obox.q.x = fixed2int_var_ceiling(cbox.q.x);
  1254.         penum->obox.q.y = fixed2int_var_ceiling(cbox.q.y);
  1255. #if 1 /*USE_FPU <= 0*/
  1256.         if ( pgs->ctm.txy_fixed_valid && pgs->char_tm.txy_fixed_valid )
  1257.           {    penum->ftx = (int)fixed2long(pgs->char_tm.tx_fixed -
  1258.                              pgs->ctm.tx_fixed);
  1259.             penum->fty = (int)fixed2long(pgs->char_tm.ty_fixed -
  1260.                              pgs->ctm.ty_fixed);
  1261.           }
  1262.         else
  1263. #endif
  1264.           {    double fdx = pgs->char_tm.tx - pgs->ctm.tx;
  1265.             double fdy = pgs->char_tm.ty - pgs->ctm.ty;
  1266. #define int_bits (arch_sizeof_int * 8 - 1)
  1267.             if ( !(f_fits_in_bits(fdx, int_bits) &&
  1268.                    f_fits_in_bits(fdy, int_bits))
  1269.                )
  1270.               return_error(gs_error_limitcheck);
  1271. #undef int_bits
  1272.             penum->ftx = (int)fdx;
  1273.             penum->fty = (int)fdy;
  1274.           }
  1275.        }
  1276.     penum->encode_char = pfont->procs.encode_char;
  1277.     return 0;
  1278. }
  1279.  
  1280. /* Set the suggested oversampling scale for character rendering. */
  1281. private void
  1282. show_set_scale(gs_show_enum *penum)
  1283. {    /* Decide whether to oversample. */
  1284.     /* We have to decide this each time setcachedevice is called. */
  1285.     const gs_state *pgs = penum->pgs;
  1286.     if ( penum->charpath_flag == cpm_show &&
  1287.          !penum->stringwidth_flag &&
  1288.          gx_path_is_void_inline(pgs->path) &&
  1289.         /* Oversampling rotated characters doesn't work well. */
  1290.          (is_fzero2(pgs->char_tm.xy, pgs->char_tm.yx) ||
  1291.           is_fzero2(pgs->char_tm.xx, pgs->char_tm.yy))
  1292.        )
  1293.       {    const gs_font_base *pfont = (gs_font_base *)pgs->font;
  1294.         gs_fixed_point extent;
  1295.         int code = gs_distance_transform2fixed(&pgs->char_tm,
  1296.             pfont->FontBBox.q.x - pfont->FontBBox.p.x,
  1297.             pfont->FontBBox.q.y - pfont->FontBBox.p.y,
  1298.             &extent);
  1299.         if ( code >= 0 )
  1300.           {    int sx =
  1301.               (extent.x == 0 ? 0 :
  1302.                any_abs(extent.x) < int2fixed(25) ? 2 :
  1303.                any_abs(extent.x) < int2fixed(60) ? 1 :
  1304.                0);
  1305.             int sy =
  1306.               (extent.y == 0 ? 0 :
  1307.                any_abs(extent.y) < int2fixed(25) ? 2 :
  1308.                any_abs(extent.y) < int2fixed(60) ? 1 :
  1309.                0);
  1310.             /* If we oversample at all, make sure we do it */
  1311.             /* in both X and Y. */
  1312.             if ( sx == 0 && sy != 0 ) sx = 1;
  1313.             else if ( sy == 0 && sx != 0 ) sy = 1;
  1314.             penum->log2_suggested_scale.x = sx;
  1315.             penum->log2_suggested_scale.y = sy;
  1316.             return;
  1317.           }
  1318.       }
  1319.     /* By default, don't scale. */
  1320.     penum->log2_suggested_scale.x =
  1321.       penum->log2_suggested_scale.y = 0;
  1322. }
  1323.  
  1324. /* Set up the cache device and related information. */
  1325. /* Note that we always allocate both cache devices, */
  1326. /* even if we only use one of them. */
  1327. private int
  1328. show_cache_setup(gs_show_enum *penum)
  1329. {    gs_state *pgs = penum->pgs;
  1330.     gs_memory_t *mem = pgs->memory;
  1331.     gx_device_memory *dev =
  1332.       gs_alloc_struct(mem, gx_device_memory, &st_device_memory,
  1333.               "show_cache_setup(dev_cache)");
  1334.     gx_device_memory *dev2 =
  1335.       gs_alloc_struct(mem, gx_device_memory, &st_device_memory,
  1336.               "show_cache_setup(dev_cache2)");
  1337.     if ( dev == 0 || dev2 == 0 )
  1338.       { gs_free_object(mem, dev2, "show_cache_setup(dev_cache2)");
  1339.         gs_free_object(mem, dev, "show_cache_setup(dev_cache)");
  1340.         return_error(gs_error_VMerror);
  1341.       }
  1342.     /* We only initialize the device for the sake of the GC, */
  1343.     /* (since we have to re-initialize it as either a mem_mono */
  1344.     /* or a mem_abuf device before actually using it) and also */
  1345.     /* to set its memory pointer. */
  1346.     gs_make_mem_mono_device(dev, mem, gs_currentdevice_inline(pgs));
  1347.     penum->dev_cache = dev;
  1348.     penum->dev_cache2 = dev2;
  1349.     /* Initialize dev2 for the sake of the GC. */
  1350.     *dev2 = *dev;
  1351.     return 0;
  1352. }
  1353.  
  1354. /* Set the character origin as the origin of the coordinate system. */
  1355. /* Used before rendering characters, and for moving the origin */
  1356. /* in setcachedevice2 when WMode=1. */
  1357. private int
  1358. show_origin_setup(gs_state *pgs, fixed cpt_x, fixed cpt_y,
  1359.   gs_char_path_mode charpath_flag)
  1360. {    if ( charpath_flag == cpm_show )
  1361.       { /* Round the translation in the graphics state. */
  1362.         /* This helps prevent rounding artifacts later. */
  1363.         cpt_x = fixed_rounded(cpt_x);
  1364.         cpt_y = fixed_rounded(cpt_y);
  1365.       }
  1366.     /*
  1367.      * BuildChar procedures expect the current point to be undefined,
  1368.      * so we omit the gx_path_add_point with ctm.t*_fixed.
  1369.      */
  1370.     return gx_translate_to_fixed(pgs, cpt_x, cpt_y);
  1371. }
  1372.  
  1373. /* Default fstack initialization procedure. */
  1374. int
  1375. gs_default_init_fstack(gs_show_enum *penum, gs_font *pfont)
  1376. {    penum->fstack.depth = -1;
  1377.     return 0;
  1378. }
  1379.  
  1380. /* Default next-character procedure. */
  1381. int
  1382. gs_default_next_char(gs_show_enum *penum, gs_char *pchr)
  1383. {    gs_glyph ignore_glyph;
  1384.     return gs_default_next_glyph(penum, pchr, &ignore_glyph);
  1385. }
  1386.  
  1387. /* Default next-glyph procedure. */
  1388. int
  1389. gs_default_next_glyph(gs_show_enum *penum, gs_char *pchr, gs_glyph *pglyph)
  1390. {    if ( penum->index == penum->str.size )
  1391.       return 2;
  1392.     *pchr = penum->str.data[penum->index++];
  1393.     *pglyph = gs_no_glyph;
  1394.     return 0;
  1395. }
  1396.